package luoguOJ;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.PriorityQueue;
import java.util.StringTokenizer;

/*

# 修复公路

## 题目背景

A 地区在地震过后，连接所有村庄的公路都造成了损坏而无法通车。政府派人修复这些公路。

## 题目描述

给出 A 地区的村庄数 $N$，和公路数 $M$，公路是双向的。并告诉你每条公路的连着哪两个村庄，并告诉你什么时候能修完这条公路。问最早什么时候任意两个村庄能够通车，即最早什么时候任意两条村庄都存在至少一条修复完成的道路（可以由多条公路连成一条道路）。

## 输入格式

第 $1$ 行两个正整数 $N,M$。

下面 $M$ 行，每行 $3$ 个正整数 $x,y,t$，告诉你这条公路连着 $x,y$ 两个村庄，在时间t时能修复完成这条公路。

## 输出格式

如果全部公路修复完毕仍然存在两个村庄无法通车，则输出 $-1$，否则输出最早什么时候任意两个村庄能够通车。

4 4
1 2 6
1 3 4
1 4 5
4 2 3

5

5 3
1 2 3
5 4 2
3 4 1

-1

5 10
1 2 1
1 3 2
1 4 6
1 5 7
2 3 5
2 4 4
2 5 10
3 4 1
3 5 8
4 5 6

6

 */

public class Main {
    
    static InOut io = new InOut();
    int n;
    int m;
    PriorityQueue<Edge> queue;
    DisjointSet set;
    
    public Main() {
        n = io.nextInt();
        m = io.nextInt();
        queue = new PriorityQueue<Edge>();
        set = new DisjointSet(n);
        for (int i = 0; i < m; i++) {
            queue.add(new Edge(io.nextInt(), io.nextInt(), io.nextInt()));
        }
    }
    
    public int kruskal() {
        int maxTime = 0;
        // 已连接边数
        int count = 0;
        // 连通n个顶点只需连n-1条边
        while (count < n-1 && !queue.isEmpty()) {
            Edge edge = queue.poll();
            int iRoot = set.findRoot(edge.i-1);
            int jRoot = set.findRoot(edge.j-1);
            // io.out.println(iRoot + ", " + jRoot);
            if (iRoot != jRoot) {
                set.union(iRoot-1, jRoot-1);
                maxTime = edge.w;
                count++;
            }
            // io.out.println(count + ", " + edge.i + "-" + edge.j + ", " + Arrays.toString(set.parent) + ", " + queue.isEmpty());
        }
        for (int i = 1; i < n; i++) {
            int iRoot = set.findRoot(i);
            int jRoot = set.findRoot(0);
            // io.out.println(iRoot + ", " + jRoot + ", " + Arrays.toString(set.parent));
            
            if (iRoot != jRoot) {
                return -1;
            }
        }
        
        return maxTime;
        
    }
    
    public static void main(String[] args) {
        Main m = new Main();
        io.out.println(m.kruskal());
        io.out.flush();
    }

}
class DisjointSet {
    int[] parent;
    int[] size;
    public DisjointSet(int n) {
        parent = new int[n];
        size = new int[n];
        for (int i = 0; i < n; i++) {
            parent[i] = i+1;
        }
    }
    public int findRoot(int i) {
        if (parent[i] == i+1) {
            return i+1;
        } else {
            parent[i] = findRoot(parent[i]-1);
            return parent[i];
        }
    }
    public void union(int i, int j) {
        if (size[i] >= size[j]) {
            parent[j] = i+1;
            size[i]++;
        } else if (size[i] < size[j]) {
            parent[i] = j+1;
            size[j]++;
        }
    }
    
}
class Edge implements Comparable<Object> {
    int i, j, w;
    public Edge(int i, int j, int w) {
        this.i = i;
        this.j = j;
        this.w = w;
    }
    @Override
    public int compareTo(Object o) {
        Edge e = (Edge) o;
        if (this.w > e.w) {
            return 1;
        } else if (this.w < e.w) {
            return -1;
        }
        return 0;
    }
    public String toString() {
        return "(" + i + ", " + j + ", " + w + ")";
    }
    
}
class InOut {
    BufferedReader br;
    StringTokenizer tok;
    PrintWriter out;
    public InOut() {
        br = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(new OutputStreamWriter(System.out));
    }
    public boolean hasNext() {
        while (tok == null || !tok.hasMoreElements()) {
            try {
                tok = new StringTokenizer(br.readLine());
            } catch (IOException e) {
                return false;
            }
        }
        return true;
    }
    public String next() {
        if (hasNext()) {
            return tok.nextToken();
        }
        return null;
    }
    public int nextInt() {
        return Integer.parseInt(next());
    }
}